﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Net;
using System.Reflection;
using System.IO;
using System.Threading;
using System.Runtime.InteropServices;

namespace PickGold.Web
{
	/// <summary>
	/// 用于处理请求的基本辅助方法。
	/// </summary>
	[ComVisible(false)]
	public class WebWorkerRequest : HttpWorkerRequest
	{
		/// <summary>
		/// HttpListenerContext
		/// </summary>
		protected HttpListenerContext _Context;
		/// <summary>
		/// HttpWebServer
		/// </summary>
		protected HttpWebServer _Server;
		/// <summary>
		/// 输入缓冲
		/// </summary>
		protected MemoryStream _InputBuffer;
		/// <summary>
		/// 输出缓冲
		/// </summary>
		protected MemoryStream _OutputBuffer;
		private int _IsEntireEntityBodyIsPreloaded;

		/// <summary>
		/// 初始化 WebWorkerRequest 类的新实例。
		/// </summary>
		/// <param name="context">HttpListenerContext</param>
		/// <param name="server">HttpWebServer</param>
		public WebWorkerRequest(HttpListenerContext context, HttpWebServer server)
		{
			if (context == null)
				throw new ArgumentNullException("context");

			if (server == null)
				throw new ArgumentNullException("server");

			this._Context = context;
			this._Server = server;
			this._IsEntireEntityBodyIsPreloaded = -1;
			//this.ReadEntityBody(null);
		}

		/// <summary>
		/// 读取请求正文
		/// </summary>
		/// <param name="state">包含回调方法要使用的信息的对象</param>
		protected virtual void ReadEntityBody(object state)
		{
			var workerRequest = state as WebWorkerRequest;
			if (state == null)
			{
				if (!this._Context.Request.HasEntityBody ||
					this._Context.Request.ContentLength64 == 0 ||
					this._IsEntireEntityBodyIsPreloaded >= 0)
					return;

				this._IsEntireEntityBodyIsPreloaded = 0;
				var async = true;
				if (async)
					ThreadPool.QueueUserWorkItem(new WaitCallback(this.ReadEntityBody), this);
				else
					this.ReadEntityBody(this);
				return;
			}

			if (workerRequest._IsEntireEntityBodyIsPreloaded > 0)
				return;

			var contentLength = workerRequest._Context.Request.ContentLength64;
			var bufferLength = BitUtil.K;
			if(bufferLength > contentLength)
				bufferLength = (int)contentLength;
			var buffer = new byte[bufferLength];
			workerRequest._InputBuffer = new MemoryStream(bufferLength);
			while (contentLength > 0)
			{
				try
				{
					var i = this._Context.Request.InputStream.Read(buffer, 0, buffer.Length);
					if (i == 0)
						break;

					if (i > contentLength)
					{
						workerRequest._InputBuffer.Write(buffer, 0, (int)contentLength);
						break;
					}

					workerRequest._InputBuffer.Write(buffer, 0, i);
					contentLength -= i;
					continue;
				}
				catch { }

				break;
			}
			workerRequest._IsEntireEntityBodyIsPreloaded = 1;
		}

		#region override abstract

		/// <summary>
		/// 由运行库使用以通知 WebWorkerRequest 当前请求的请求处理已完成。
		/// </summary>
		public override void EndOfRequest()
		{
			//base.EndOfRequest();
			try
			{
				this._Context.Response.OutputStream.Close();
			}
			catch { }
			try
			{
				this._Context.Response.Close();
			}
			catch { }
			//this._Context.Close();
		}

		/// <summary>
		/// 将所有挂起的响应数据发送到客户端。
		/// </summary>
		/// <param name="finalFlush">如果这将是最后一次刷新响应数据，则为 true；否则为 false。</param>
		public override void FlushResponse(bool finalFlush)
		{
			//base.FlushResponse(finalFlush);
			this._Context.Response.OutputStream.Flush();
			//if (!finalFlush)
			//    return;

			//this._Context.Response.OutputStream.Close();
			//this._Context.Response.Close();
		}

		/// <summary>
		/// 返回请求标头的指定成员。
		/// </summary>
		/// <returns>请求标头中返回的 HTTP 谓词。</returns>
		public override string GetHttpVerbName()
		{
			//base.GetHttpVerbName();
			return this._Context.Request.HttpMethod;
		}

		/// <summary>
		/// 提供对请求的 HTTP 版本（如“HTTP/1.1”）的访问。
		/// </summary>
		/// <returns>请求标头中返回的 HTTP 版本。</returns>
		public override string GetHttpVersion()
		{
			//base.GetHttpVersion();
			return string.Format("HTTP/{0}.{1}", this._Context.Request.ProtocolVersion.Major, this._Context.Request.ProtocolVersion.Minor);
		}

		/// <summary>
		/// 提供对请求标头的指定成员的访问。
		/// </summary>
		/// <returns>请求标头中返回的服务器 IP 地址。</returns>
		public override string GetLocalAddress()
		{
			//base.GetLocalAddress();
			return this._Context.Request.LocalEndPoint.Address + string.Empty;
		}

		/// <summary>
		/// 提供对请求标头的指定成员的访问。
		/// </summary>
		/// <returns>请求标头中返回的服务器端口号。</returns>
		public override int GetLocalPort()
		{
			//base.GetLocalPort();
			return this._Context.Request.LocalEndPoint.Port;
		}

		/// <summary>
		/// 返回请求 URL 中指定的查询字符串。
		/// </summary>
		/// <returns>请求查询字符串。</returns>
		public override string GetQueryString()
		{
			//base.GetQueryString();
			var rawUrl = this._Context.Request.RawUrl;
			var index = rawUrl.IndexOf('?') + 1;
			if (index > 0)
				return rawUrl.Substring(index);

			return string.Empty;
		}

		/// <summary>
		/// 返回附加了查询字符串的请求标头中包含的 URL 路径。
		/// </summary>
		/// <returns>请求标头的原始 URL 路径。</returns>
		public override string GetRawUrl()
		{
			//base.GetRawUrl();
			return this._Context.Request.RawUrl;
		}

		/// <summary>
		/// 提供对请求标头的指定成员的访问。
		/// </summary>
		/// <returns>客户端的 IP 地址。</returns>
		public override string GetRemoteAddress()
		{
			//base.GetRemoteAddress();
			return this._Context.Request.RemoteEndPoint.Address + string.Empty;
		}

		/// <summary>
		/// 提供对请求标头的指定成员的访问。
		/// </summary>
		/// <returns>客户端的 HTTP 端口号。</returns>
		public override int GetRemotePort()
		{
			//base.GetRemotePort();
			return this._Context.Request.RemoteEndPoint.Port;
		}

		/// <summary>
		/// 返回请求的 URI 的虚拟路径。
		/// </summary>
		/// <returns>请求的 URI 的路径。</returns>
		public override string GetUriPath()
		{
			//base.GetUriPath();
			return this._Context.Request.Url.LocalPath;
		}

		/// <summary>
		/// 将标准 HTTP 标头添加到响应。
		/// </summary>
		/// <param name="index">标头索引。例如 System.Web.HttpWorkerRequest.HeaderContentLength。</param>
		/// <param name="value">标头的值。</param>
		public override void SendKnownResponseHeader(int index, string value)
		{
			//base.SendKnownResponseHeader(index, value);
			this._Context.Response.Headers[HttpWorkerRequest.GetKnownResponseHeaderName(index)] = value;
		}

		/// <summary>
		/// 将字节数组中指定数目的字节添加到响应。
		/// </summary>
		/// <param name="data">要发送的字节数组。</param>
		/// <param name="length">要发送的字节数（从第一个字节开始）。</param>
		public override void SendResponseFromMemory(byte[] data, int length)
		{
			//base.SendResponseFromMemory(data, length);
			this._Context.Response.OutputStream.Write(data, 0, length);
		}

		/// <summary>
		/// 指定响应的 HTTP 状态代码和状态说明，例如 SendStatus(200, "Ok")。
		/// </summary>
		/// <param name="statusCode">要发送的状态代码</param>
		/// <param name="statusDescription">要发送的状态说明。</param>
		public override void SendStatus(int statusCode, string statusDescription)
		{
			//base.SendStatus(statusCode, statusDescription);
			this._Context.Response.StatusCode = statusCode;
			this._Context.Response.StatusDescription = statusDescription;
		}

		/// <summary>
		/// 将非标准 HTTP 标头添加到响应。
		/// </summary>
		/// <param name="name">要发送的标头的名称。</param>
		/// <param name="value">标头的值。</param>
		public override void SendUnknownResponseHeader(string name, string value)
		{
			//base.SendUnknownResponseHeader(name, value);
			this._Context.Response.Headers[name] = value;
		}

		/// <summary>
		/// 将指定文件的内容添加到响应并指定文件中的起始位置和要发送的字节数。
		/// </summary>
		/// <param name="handle">要发送的文件的句柄。</param>
		/// <param name="offset">文件中的起始位置。</param>
		/// <param name="length">要发送的字节数。</param>
		public override void SendResponseFromFile(IntPtr handle, long offset, long length)
		{
			//base.SendResponseFromFile(handle, offset, length);
			var stream = new FileStream(handle, FileAccess.Read);
			this.SendResponseFromStream(stream, offset, length);
			stream.Close();
		}

		/// <summary>
		/// 将指定文件的内容添加到响应并指定文件中的起始位置和要发送的字节数。
		/// </summary>
		/// <param name="filename">要发送的文件的名称。</param>
		/// <param name="offset">文件中的起始位置。</param>
		/// <param name="length">要发送的字节数。</param>
		public override void SendResponseFromFile(string filename, long offset, long length)
		{
			//base.SendResponseFromFile(filename, offset, length);
			var stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
			this.SendResponseFromStream(stream, offset, length);
			stream.Close();
		}

		/// <summary>
		/// 将指定流中的内容添加到响应并指定文件中的起始位置和要发送的字节数。
		/// </summary>
		/// <param name="stream">要发送的流</param>
		/// <param name="offset">流中的起始位置</param>
		/// <param name="length">要发送的字节数</param>
		public virtual void SendResponseFromStream(Stream stream, long offset, long length)
		{
			if (stream.CanSeek)
				stream.Seek(offset, SeekOrigin.Begin);
			var i = BitUtil.K;
			if (i > length)
				i = (int)length;
			var bs = new byte[i];
			while (length > 0)
			{
				i = bs.Length;
				if (i > length)
					i = (int)length;
				i = stream.Read(bs, 0, i);
				if (i == 0)
					return;

				this._Context.Response.OutputStream.Write(bs, 0, i);
				offset += i;
				length -= i;
			}
		}

		#endregion

		#region override virtual

		/// <summary>
		/// 获取 Machine.config 文件的完整物理路径。
		/// </summary>
		public override string MachineConfigPath
		{
			get
			{
				var path = base.MachineConfigPath;
				return path;
			}
		}
		/// <summary>
		/// 获取 ASP.NET 二进制文件的安装目录的物理路径。
		/// </summary>
		public override string MachineInstallDirectory
		{
			get
			{
				var path = base.MachineInstallDirectory;
				return path;
			}
		}
		/// <summary>
		/// 获取当前请求的 Windows 跟踪 ID 的对应事件跟踪。
		/// </summary>
		public override Guid RequestTraceIdentifier
		{
			get
			{
				return this._Context.Request.RequestTraceIdentifier;
			}
		}
		/// <summary>
		/// 获取根 Web.config 文件的完整物理路径。
		/// </summary>
		public override string RootWebConfigPath
		{
			get
			{
				var path = base.RootWebConfigPath;
				if (string.IsNullOrEmpty(path))
				{
					path = Path.Combine(this._Server.PhysicalPath, "web.config");
					if (File.Exists(path))
						return path;

					path = Path.Combine(this._Server.PhysicalPath, @"bin\web.config");
					if (File.Exists(path))
						return path;

					path = string.Empty;
				}
				return path;
			}
		}

		/// <summary>
		/// 终止与客户端的连接。
		/// </summary>
		public override void CloseConnection()
		{
			this._Context.Response.Close();
		}
		/// <summary>
		/// 返回当前正在执行的服务器应用程序的虚拟路径。
		/// </summary>
		/// <returns>当前应用程序的虚拟路径。</returns>
		public override string GetAppPath()
		{
			if (string.IsNullOrEmpty(this._Server.VirtualPath))
				return base.GetAppPath();

			return this._Server.VirtualPath;
		}
		/// <summary>
		/// 返回当前正在执行的服务器应用程序的物理路径。
		/// </summary>
		/// <returns>当前应用程序的物理路径。</returns>
		public override string GetAppPathTranslated()
		{
			if(string.IsNullOrEmpty(this._Server.PhysicalPath))
				return base.GetAppPathTranslated();

			return this._Server.PhysicalPath;
		}
		//
		// 摘要:
		//     在派生类中被重写时，返回当前 URL 的应用程序池 ID。
		//
		// 返回结果:
		//     始终返回 null。
		//public virtual string GetAppPoolID();
		//public override string GetAppPoolID()
		//{
		//    var o = base.GetAppPoolID();
		//    return o;
		//}
		/// <summary>
		/// 获取从客户端读入的字节数。
		/// </summary>
		/// <returns>包含读取的字节数的 Long。</returns>
		public override long GetBytesRead()
		{
			if (this._IsEntireEntityBodyIsPreloaded < 0)
				this.ReadEntityBody(null);
			if(this._InputBuffer == null)
				return base.GetBytesRead();

			return this._InputBuffer.Length;
		}
		//
		// 摘要:
		//     在派生类中被重写时，从客户端发出的请求获取证书字段（以 X.509 标准指定）。
		//
		// 返回结果:
		//     包含整个证书内容流的字节数组。
		//public virtual byte[] GetClientCertificate();
		//public override byte[] GetClientCertificate()
		//{
		//    var o = base.GetClientCertificate();
		//    return o;
		//}
		//
		// 摘要:
		//     获取证书颁发者（以二进制格式表示）。
		//
		// 返回结果:
		//     包含以二进制格式表示的证书颁发者的字节数组。
		//public virtual byte[] GetClientCertificateBinaryIssuer();
		//public override byte[] GetClientCertificateBinaryIssuer()
		//{
		//    var o = base.GetClientCertificateBinaryIssuer();
		//    return o;
		//}
		//
		// 摘要:
		//     在派生类中被重写时，返回用于编码客户端证书的 System.Text.Encoding 对象。
		//
		// 返回结果:
		//     表示为整数的证书编码。
		//public virtual int GetClientCertificateEncoding();
		//public override int GetClientCertificateEncoding()
		//{
		//    var o = base.GetClientCertificateEncoding();
		//    return o;
		//}
		//
		// 摘要:
		//     在派生类中被重写时，获取与客户端证书关联的 PublicKey 对象。
		//
		// 返回结果:
		//     一个 PublicKey 对象。
		//public virtual byte[] GetClientCertificatePublicKey();
		//public override byte[] GetClientCertificatePublicKey()
		//{
		//    var o = base.GetClientCertificatePublicKey();
		//    return o;
		//}
		//
		// 摘要:
		//     在派生类中被重写时，则获取证书开始生效的日期。此日期随区域设置的不同而不同。
		//
		// 返回结果:
		//     表示证书生效时间的 System.DateTime 对象。
		//public virtual DateTime GetClientCertificateValidFrom();
		//public override DateTime GetClientCertificateValidFrom()
		//{
		//    var o = base.GetClientCertificateValidFrom();
		//    return o;
		//}
		//
		// 摘要:
		//     获取证书到期日期。
		//
		// 返回结果:
		//     表示证书失效日期的 System.DateTime 对象。
		//public virtual DateTime GetClientCertificateValidUntil();
		//public override DateTime GetClientCertificateValidUntil()
		//{
		//    var o = base.GetClientCertificateValidUntil();
		//    return o;
		//}
		//
		// 摘要:
		//     在派生类中被重写时，返回当前连接的 ID。
		//
		// 返回结果:
		//     始终返回 0。
		//public virtual long GetConnectionID();
		//public override long GetConnectionID()
		//{
		//    var o = base.GetConnectionID();
		//    return o;
		//}
		//
		// 摘要:
		//     在派生类中被重写时，返回所请求的 URI 的虚拟路径。
		//
		// 返回结果:
		//     请求的 URI 的路径。
		//public virtual string GetFilePath();
		//public override string GetFilePath()
		//{
		//    var o = base.GetFilePath();
		//    return o;
		//}
		/// <summary>
		/// 返回请求的 URI 的物理文件路径（并将其从虚拟路径转换成物理路径：例如，从“/proj1/page.aspx”转换成“c:\dir\page.aspx”）
		/// </summary>
		/// <returns>请求的 URI 的已转换的物理文件路径。</returns>
		public override string GetFilePathTranslated()
		{
			var path = this.GetFilePath();
			path = this.MapPath(path);
			if (string.IsNullOrEmpty(path))
				return base.GetFilePathTranslated();

			return path;
		}
		/// <summary>
		/// 返回与指定的索引相对应的标准 HTTP 请求标头。
		/// </summary>
		/// <param name="index">标头的索引。例如，System.Web.HttpWorkerRequest.HeaderAllow 字段。</param>
		/// <returns>HTTP 请求标头。</returns>
		public override string GetKnownRequestHeader(int index)
		{
			//if (HttpWorkerRequest.HeaderAccept == index)
			//    return string.Join(", ", this._Context.Request.AcceptTypes);
			//    return this._Context.Request.ClientCertificateError;
			if (HttpWorkerRequest.HeaderContentEncoding == index)
				return this._Context.Request.ContentEncoding.WebName;
			if (HttpWorkerRequest.HeaderContentLength == index)
				return this._Context.Request.ContentLength64.ToString();
			if (HttpWorkerRequest.HeaderContentType == index)
				return this._Context.Request.ContentType;
			//if (HttpWorkerRequest.HeaderCookie == index)
			//    return this._Context.Request.Cookies.ToString();
			//    return this._Context.Request.HasEntityBody;
			//    return this._Context.Request.Headers;
			//    return this._Context.Request.HttpMethod;
			//    return this._Context.Request.InputStream;
			//    return this._Context.Request.IsAuthenticated;
			//    return this._Context.Request.IsLocal;
			//    return this._Context.Request.IsSecureConnection;
			if (HttpWorkerRequest.HeaderKeepAlive == index)
				return this._Context.Request.KeepAlive.ToString();
			//    return this._Context.Request.LocalEndPoint;
			//    return this._Context.Request.ProtocolVersion;
			//    return this._Context.Request.QueryString;
			//    return this._Context.Request.RawUrl;
			//    return this._Context.Request.RemoteEndPoint;
			//    return this._Context.Request.RequestTraceIdentifier;
			//    return this._Context.Request.Url;
			//if (HttpWorkerRequest.HeaderReferer == index)
			//    return this._Context.Request.UrlReferrer + string.Empty;
			if (HttpWorkerRequest.HeaderUserAgent == index)
				return this._Context.Request.UserAgent;
			//    return this._Context.Request.UserHostAddress;
			//if (HttpWorkerRequest.HeaderServer == index)
			//    return this._Context.Request.UserHostName;
			if (HttpWorkerRequest.HeaderContentLanguage == index)
				return string.Join(", ", this._Context.Request.UserLanguages);
			var t = HttpWorkerRequest.GetKnownRequestHeaderName(index);
			return this._Context.Request.Headers[t];
		}
		//
		// 摘要:
		//     返回具有 URL 扩展的资源的其他路径信息。即对于路径 /virdir/page.html/tail，GetPathInfo 值为 /tail。
		//
		// 返回结果:
		//     资源的附加路径信息。
		//public virtual string GetPathInfo();
		//public override string GetPathInfo()
		//{
		//    var o = base.GetPathInfo();
		//    return o;
		//}
		/// <summary>
		/// 返回 HTTP 请求正文已被读取的部分。
		/// </summary>
		/// <returns>HTTP 请求正文已被读取的部分。</returns>
		public override byte[] GetPreloadedEntityBody()
		{
			if (this._IsEntireEntityBodyIsPreloaded < 0)
				this.ReadEntityBody(null);
			if (this._InputBuffer == null)
				return base.GetPreloadedEntityBody();

			return this._InputBuffer.ToArray();
		}
		/// <summary>
		/// 使用指定的缓冲区数据和字节偏移量获取 HTTP 请求正文当前已被读取的部分。
		/// </summary>
		/// <param name="buffer">要读取的数据。</param>
		/// <param name="offset">开始读取的位置的字节偏移量。</param>
		/// <returns>HTTP 请求正文已被读取的部分。</returns>
		public override int GetPreloadedEntityBody(byte[] buffer, int offset)
		{
			if (this._IsEntireEntityBodyIsPreloaded < 0)
				this.ReadEntityBody(null);
			if (this._InputBuffer == null || this._InputBuffer.Length > offset)
				return base.GetPreloadedEntityBody(buffer, offset);

			var size = this._InputBuffer.Length - offset;
			if (size > buffer.Length)
				size = buffer.Length;
			Array.Copy(this._InputBuffer.ToArray(), offset, buffer, 0, size);
			if (size > int.MaxValue)
				return int.MaxValue;

			return (int)size;
		}
		/// <summary>
		/// 获取 HTTP 请求正文当前已被读取部分的长度。
		/// </summary>
		/// <returns>一个整数，包含当前已读取的 HTTP 请求正文的长度。</returns>
		public override int GetPreloadedEntityBodyLength()
		{
			if (this._IsEntireEntityBodyIsPreloaded < 0)
				this.ReadEntityBody(null);
			if (this._InputBuffer == null)
				return base.GetPreloadedEntityBodyLength();

			if (this._InputBuffer.Length > int.MaxValue)
				return int.MaxValue;

			return (int)this._InputBuffer.Length;
		}
		//
		// 摘要:
		//     在派生类中被重写时，返回 HTTP 协议（HTTP 或 HTTPS）。
		//
		// 返回结果:
		//     如果 System.Web.HttpWorkerRequest.IsSecure() 方法为 true，则为 HTTPS；否则，为 HTTP。
		//public virtual string GetProtocol();
		//public override string GetProtocol()
		//{
		//    var o = base.GetProtocol();
		//    return o;
		//}
		/// <summary>
		/// 以字节数组的形式返回响应查询字符串。
		/// </summary>
		/// <returns>包含响应的字节数组。</returns>
		public override byte[] GetQueryStringRawBytes()
		{
			//this._Context.Request.QueryString
			var queryString = this._Context.Request.Url.Query;
			if(string.IsNullOrEmpty(queryString))
				return base.GetQueryStringRawBytes();

			queryString = queryString.Substring(1);
			if(string.IsNullOrEmpty(queryString))
				return base.GetQueryStringRawBytes();

			return this._Context.Request.ContentEncoding.GetBytes(queryString);
		}
		//
		// 摘要:
		//     返回附加了查询字符串的请求标头中包含的 URL 路径。
		//
		// 返回结果:
		//     请求标头的原始 URL 路径。
		//public abstract string GetRawUrl();
		//
		// 摘要:
		//     提供对请求标头的指定成员的访问。
		//
		// 返回结果:
		//     客户端的 IP 地址。
		//public abstract string GetRemoteAddress();
		//
		// 摘要:
		//     在派生类中被重写时，返回客户端计算机的名称。
		//
		// 返回结果:
		//     客户端计算机的名称。
		//public virtual string GetRemoteName();
		//public override string GetRemoteName()
		//{
		//    var o = base.GetRemoteName();
		//    return o;
		//}
		//
		// 摘要:
		//     提供对请求标头的指定成员的访问。
		//
		// 返回结果:
		//     客户端的 HTTP 端口号。
		//public abstract int GetRemotePort();
		//
		// 摘要:
		//     在派生类中被重写时，返回请求的原因。
		//
		// 返回结果:
		//     原因代码。默认值为 ReasonResponseCacheMiss。
		//public virtual int GetRequestReason();
		//public override int GetRequestReason()
		//{
		//    var o = base.GetRequestReason();
		//    return o;
		//}
		//
		// 摘要:
		//     在派生类中被重写时，返回本地服务器的名称。
		//
		// 返回结果:
		//     本地服务器的名称。
		//public virtual string GetServerName();
		//public override string GetServerName()
		//{
		//    var o = base.GetServerName();
		//    return o;
		//}
		/// <summary>
		/// 从与请求关联的服务器变量词典返回单个服务器变量。
		/// </summary>
		/// <param name="name">请求的服务器变量的名称。</param>
		/// <returns>请求的服务器变量。</returns>
		public override string GetServerVariable(string name)
		{
			var value = base.GetServerVariable(name);
			if (string.IsNullOrEmpty(value))
				value = this._Server.GetApplicationItem(name) + string.Empty;
			return value;
		}
		/// <summary>
		/// 获取整个 HTTP 请求正文的长度。
		/// </summary>
		/// <returns>包含整个 HTTP 请求正文的长度的整数。</returns>
		public override int GetTotalEntityBodyLength()
		{
			if (this._IsEntireEntityBodyIsPreloaded > 1)
				return base.GetTotalEntityBodyLength();

			if (this._Context.Request.ContentLength64 > int.MaxValue)
				return int.MaxValue;

			if (this._Context.Request.ContentLength64 > int.MaxValue)
				return int.MaxValue;

			return (int)this._Context.Request.ContentLength64;
		}
		/// <summary>
		/// 返回非标准的 HTTP 请求标头值。
		/// </summary>
		/// <param name="name">标头名称。</param>
		/// <returns>标头值。</returns>
		public override string GetUnknownRequestHeader(string name)
		{
			return this._Context.Response.Headers[name];
		}
		/// <summary>
		/// 获取所有非标准的 HTTP 标头的名称/值对。
		/// </summary>
		/// <returns>标头的名称/值对的数组。</returns>
		//[CLSCompliant(false)]
		public override string[][] GetUnknownRequestHeaders()
		{
			var ls = new List<string[]>();
			foreach(string key in this._Context.Request.Headers.Keys)
			{
				if (HttpWorkerRequest.GetKnownRequestHeaderIndex(key) >= 0)
					continue;

				ls.Add(new string[] { key, this._Context.Request.Headers[key] });
			}
			return ls.ToArray();
		}
		//
		// 摘要:
		//     返回请求的 URI 的虚拟路径。
		//
		// 返回结果:
		//     请求的 URI 的路径。
		//public abstract string GetUriPath();
		//
		// 摘要:
		//     当在派生类中被重写时，返回当前连接的上下文 ID。
		//
		// 返回结果:
		//     始终返回 0。
		//public virtual long GetUrlContextID();
		//public override long GetUrlContextID()
		//{
		//    var o = base.GetUrlContextID();
		//    return o;
		//}
		//
		// 摘要:
		//     在派生类中被重写时，返回客户端的模拟标记。
		//
		// 返回结果:
		//     表示客户端的模拟标记的值。默认值为 0。
		//public virtual IntPtr GetUserToken();
		//public override IntPtr GetUserToken()
		//{
		//    var o = base.GetUserToken();
		//    return o;
		//}
		//
		// 摘要:
		//     获取请求虚拟路径的模拟标记。
		//
		// 返回结果:
		//     请求虚拟路径的标记的非托管内存指针。
		//public virtual IntPtr GetVirtualPathToken();
		//public override IntPtr GetVirtualPathToken()
		//{
		//    var o = base.GetVirtualPathToken();
		//    return o;
		//}
		//
		// 摘要:
		//     返回一个值，该值指示请求是否包含正文数据。
		//
		// 返回结果:
		//     如果请求包含正文数据，则为 true；否则，为 false。
		//public bool HasEntityBody();
		//
		// 摘要:
		//     返回一个值，该值指示是否已为当前的请求将 HTTP 响应标头发送到客户端。
		//
		// 返回结果:
		//     如果 HTTP 响应标头已发送到客户端，则为 true；否则，为 false。
		//public virtual bool HeadersSent();
		//public override bool HeadersSent()
		//{
		//    var o = base.HeadersSent();
		//    return o;
		//}
		//
		// 摘要:
		//     返回一个值，该值指示客户端连接是否仍处于活动状态。
		//
		// 返回结果:
		//     如果客户端连接仍处于活动状态，则为 true；否则，为 false。
		//public virtual bool IsClientConnected();
		//public override bool IsClientConnected()
		//{
		//    var o = base.IsClientConnected();
		//    return o;
		//}
		/// <summary>
		/// 返回一个值，该值指示是否所有请求数据都可用，以及是否不需要对客户端进行进一步读取。
		/// </summary>
		/// <returns>如果所有请求数据都可用，则为 true；否则，为 false。</returns>
		public override bool IsEntireEntityBodyIsPreloaded()
		{
			if (this._IsEntireEntityBodyIsPreloaded < 0)
				this.ReadEntityBody(null);
			if (this._InputBuffer == null)
				return base.IsEntireEntityBodyIsPreloaded();

			return this._IsEntireEntityBodyIsPreloaded > 0;
		}
		/// <summary>
		/// 返回一个指示连接是否使用 SSL 的值。
		/// </summary>
		/// <returns>如果连接是 SSL 连接，则为 true；否则为 false。默认值为 false。</returns>
		public override bool IsSecure()
		{
			if (base.IsSecure() || this._Context.Request.IsSecureConnection)
				return true;

			return false;
		}
		/// <summary>
		/// 返回与指定虚拟路径相对应的物理路径。
		/// </summary>
		/// <param name="virtualPath">虚拟路径。</param>
		/// <returns>与 virtualPath 参数中指定的虚拟路径相对应的物理路径。</returns>
		public override string MapPath(string virtualPath)
		{
			var url = new Uri(this._Context.Request.Url, virtualPath);
			var localPath = url.LocalPath;
			var vPath = this.GetAppPath();
			if (!localPath.StartsWith(vPath))
				return base.MapPath(virtualPath);

			localPath = localPath.Substring(vPath.Length);
			localPath = localPath.Replace('/', '\\');
			var pPath = this.GetAppPathTranslated();
			return Path.Combine(pPath, localPath);
		}
		/// <summary>
		/// 读取客户端的请求数据（在尚未预加载时）。
		/// </summary>
		/// <param name="buffer">将数据读入的字节数组。</param>
		/// <param name="size">最多读取的字节数。</param>
		/// <returns>读取的字节数。</returns>
		public override int ReadEntityBody(byte[] buffer, int size)
		{
			//if (this._IsEntireEntityBodyIsPreloaded < 0)
			//    this.ReadEntityBody(null);
			//if (this._InputBuffer == null)
			//    return base.ReadEntityBody(buffer, size);

			//if (size > this._InputBuffer.Length)
			//    size = (int)this._InputBuffer.Length;
			//Array.Copy(this._InputBuffer.ToArray(), buffer, size);
			//return size;
			this._IsEntireEntityBodyIsPreloaded = 2;
			return this._Context.Request.InputStream.Read(buffer, 0, size);
		}
		/// <summary>
		/// 使用指定的要从中读取数据的缓冲区、字节偏移量和最大字节数从客户端读取请求数据（当未预先加载时）。
		/// </summary>
		/// <param name="buffer">将数据读入的字节数组。</param>
		/// <param name="offset">开始读取的位置的字节偏移量。</param>
		/// <param name="size">最多读取的字节数。</param>
		/// <returns>读取的字节数。</returns>
		public override int ReadEntityBody(byte[] buffer, int offset, int size)
		{
			//if (this._IsEntireEntityBodyIsPreloaded < 0)
			//    this.ReadEntityBody(null);
			//if (this._InputBuffer == null || offset > this._InputBuffer.Length)
			//    return base.ReadEntityBody(buffer, offset, size);

			//if (offset + size > this._InputBuffer.Length)
			//{
			//    if (this._InputBuffer.Length - offset > int.MaxValue)
			//        size = int.MaxValue;
			//    else
			//        size = (int)(this._InputBuffer.Length - offset);
			//}
			//Array.Copy(this._InputBuffer.ToArray(), offset, buffer, 0, size);
			//return size;
			this._IsEntireEntityBodyIsPreloaded = 2;
			return this._Context.Request.InputStream.Read(buffer, offset, size);
		}
		//
		// 摘要:
		//     将 Content-Length HTTP 标头添加到小于或等于 2 GB 的消息正文的响应。
		//
		// 参数:
		//   contentLength:
		//     响应的长度（以字节为单位）。
		//public virtual void SendCalculatedContentLength(int contentLength);
		//public override void SendCalculatedContentLength(int contentLength)
		//{
		//    base.SendCalculatedContentLength(contentLength);
		//}
		//
		// 摘要:
		//     将 Content-Length HTTP 标头添加到大于 2 GB 的消息正文的响应。
		//
		// 参数:
		//   contentLength:
		//     响应的长度（以字节为单位）。
		//public virtual void SendCalculatedContentLength(long contentLength);
		//public override void SendCalculatedContentLength(long contentLength)
		//{
		//    base.SendCalculatedContentLength(contentLength);
		//}
		//
		// 摘要:
		//     将标准 HTTP 标头添加到响应。
		//
		// 参数:
		//   index:
		//     标头索引。例如 System.Web.HttpWorkerRequest.HeaderContentLength。
		//
		//   value:
		//     标头的值。
		//public abstract void SendKnownResponseHeader(int index, string value);
		//
		// 摘要:
		//     将指定文件的内容添加到响应并指定文件中的起始位置和要发送的字节数。
		//
		// 参数:
		//   handle:
		//     要发送的文件的句柄。
		//
		//   offset:
		//     文件中的起始位置。
		//
		//   length:
		//     要发送的字节数。
		//public abstract void SendResponseFromFile(IntPtr handle, long offset, long length);
		//
		// 摘要:
		//     将指定文件的内容添加到响应并指定文件中的起始位置和要发送的字节数。
		//
		// 参数:
		//   filename:
		//     要发送的文件的名称。
		//
		//   offset:
		//     文件中的起始位置。
		//
		//   length:
		//     要发送的字节数。
		//public abstract void SendResponseFromFile(string filename, long offset, long length);
		//
		// 摘要:
		//     将字节数组中指定数目的字节添加到响应。
		//
		// 参数:
		//   data:
		//     要发送的字节数组。
		//
		//   length:
		//     要发送的字节数（从第一个字节开始）。
		//public abstract void SendResponseFromMemory(byte[] data, int length);
		//
		// 摘要:
		//     将内存块中指定数目的字节添加到响应。
		//
		// 参数:
		//   data:
		//     指向内存块的非托管指针。
		//
		//   length:
		//     要发送的字节数。
		//public virtual void SendResponseFromMemory(IntPtr data, int length);
		//public override void SendResponseFromMemory(IntPtr data, int length)
		//{
		//    base.SendResponseFromMemory(data, length);
		//}
		//
		// 摘要:
		//     指定响应的 HTTP 状态代码和状态说明，例如 SendStatus(200, "Ok")。
		//
		// 参数:
		//   statusCode:
		//     要发送的状态代码
		//
		//   statusDescription:
		//     要发送的状态说明。
		//public abstract void SendStatus(int statusCode, string statusDescription);
		//
		// 摘要:
		//     将非标准 HTTP 标头添加到响应。
		//
		// 参数:
		//   name:
		//     要发送的标头的名称。
		//
		//   value:
		//     标头的值。
		//public abstract void SendUnknownResponseHeader(string name, string value);
		//
		// 摘要:
		//     在发送所有响应数据后注册可选通知。
		//
		// 参数:
		//   callback:
		//     在发送所有数据（带外）后调用的通知回调。
		//
		//   extraData:
		//     回调的附加参数。
		//public virtual void SetEndOfSendNotification(HttpWorkerRequest.EndOfSendNotification callback, object extraData);
		//public override void SetEndOfSendNotification(HttpWorkerRequest.EndOfSendNotification callback, object extraData)
		//{
		//    base.SetEndOfSendNotification(callback, extraData);
		//}

		// 摘要:
		//     表示用于在完成发送响应后通知调用方的方法。
		//
		// 参数:
		//   wr:
		//     当前的 System.Web.HttpWorkerRequest。
		//
		//   extraData:
		//     处理请求所需的任何其他数据。
		//public delegate void EndOfSendNotification(HttpWorkerRequest wr, object extraData);

		#endregion
	}
}
